base

What is base?

The 'base' npm package is a framework for rapidly building high-quality node.js applications, using plugins like building blocks. It's designed to be a foundation on which to build complex applications.

What are base's main functionalities?

Plugin Management

Base allows you to easily manage and use plugins, enabling modular application development. Plugins can add specific functionalities to the base application, which can be initialized and used as needed.

const Base = require('base');
const app = new Base();
app.use(require('some-plugin'));
app.init();

Event Handling

Base provides an event handling system. You can define custom events and handlers, making it easy to manage events within your application.

const Base = require('base');
const app = new Base();
app.on('event', () => console.log('Event triggered!'));
app.emit('event');

Task Execution

Base supports defining and running tasks. This feature allows you to organize code into tasks that can be executed on demand, simplifying complex operations into manageable units.

const Base = require('base');
const app = new Base();
app.task('do something', () => console.log('Task done!'));
app.run('do something');

Other packages similar to base

express

Express is a web application framework for Node.js, designed for building web applications and APIs. It differs from Base in that it's specifically tailored for HTTP server functionality, whereas Base is more generalized and plugin-oriented.

hapi

Hapi is another Node.js framework for building applications and services. Hapi is similar to Base in that it supports plugins, but it is more focused on server-side applications and provides a robust configuration-led approach, compared to Base's flexible plugin system.

README

base

base is the foundation for creating modular, unit testable and highly pluggable node.js applications, starting with a handful of common methods, like set, get, del and use.

• Install
• Usage
• API
• Test coverage
• Related projects
• Running tests
• Contributing
• Author
• License

(TOC generated by verb using markdown-toc)

Install

Install with npm:

$ npm i base --save

Usage

var base = require('base');

inherit

function App() {
  base.call(this);
}
base.extend(App);

var app = new App();
app.set('a', 'b');
app.get('a');
//=> 'b';

instantiate

var app = base();
app.set('foo', 'bar');
console.log(app.foo);
//=> 'bar'

Inherit or instantiate with a namespace

A .namespace() method is exposed on the exported function to allow you to create a custom namespace for setting/getting on the instance.

var Base = require('base')
var base = Base.namespace('cache');

var app = base();
app.set('foo', 'bar');
console.log(app.cache.foo);
//=> 'bar'

API

Base

Create an instance of Base with options.

Params

• options {Object}

Example

var app = new Base();
app.set('foo', 'bar');
console.log(app.get('foo'));
//=> 'bar'

.is

Set the given name on app._name and app.is* properties. Used for doing lookups in plugins.

Params

• name {String}
• returns {Boolean}

Example

app.is('foo');
console.log(app._name);
//=> 'foo'
console.log(app.isFoo);
//=> true
app.is('bar');
console.log(app.isFoo);
//=> true
console.log(app.isBar);
//=> true
console.log(app._name);
//=> 'bar'

.isRegistered

Returns true if a plugin has already been registered on an instance.

Plugin implementors are encouraged to use this first thing in a plugin to prevent the plugin from being called more than once on the same instance.

Params

• name {String}: The plugin name.
• returns {Boolean}: Returns true when a plugin is already registered.

Events

• emits: plugin with registered and the name of the plugin as arguments.

Example

var base = new Base();
base.use(function(app) {
  if (app.isRegistered('myPlugin')) return;
  // do stuff to `app`
});

.use

Define a plugin function to be called immediately upon init. Plugins are chainable and the only parameter exposed to the plugin is the application instance.

Params

• fn {Function}: plugin function to call
• returns {Object}: Returns the item instance for chaining.

Events

• emits: use with no arguments.

Example

var app = new Base()
  .use(foo)
  .use(bar)
  .use(baz)

.lazy

Lazily invoke a registered plugin. This can only be used with:

1. plugins that add a single method or property to app
2. plugins that do not add a getter/setter property
3. plugins that do not return a function

Params

• prop {String}: The name of the property or method added by the plugin.
• fn {Function}: The plugin function
• options {Object}: Options to use when the plugin is invoked.
• returns {Object}: Returns the instance for chaining

Example

app.lazy('store', require('base-store'));

.set

Assign value to key. Also emits set with the key and value.

Params

• key {String}
• value {any}
• returns {Object}: Returns the instance for chaining.

Events

• emits: set with key and value as arguments.

Example

app.on('set', function(key, val) {
  // do something when `set` is emitted
});

app.set(key, value);

// also takes an object or array
app.set({name: 'Halle'});
app.set([{foo: 'bar'}, {baz: 'quux'}]);
console.log(app);
//=> {name: 'Halle', foo: 'bar', baz: 'quux'}

.get

Return the stored value of key. Dot notation may be used to get [nested property values][get-value].

Params

• key {String}: The name of the property to get. Dot-notation may be used.
• returns {any}: Returns the value of key

Events

• emits: get with key and value as arguments.

Example

app.set('a.b.c', 'd');
app.get('a.b');
//=> {c: 'd'}

app.get(['a', 'b']);
//=> {c: 'd'}

.has

Return true if app has a stored value for key, false only if typeof value is undefined.

Params

• key {String}
• returns {Boolean}

Events

• emits: has with key and true or false as arguments.

Example

app.set('foo', 'bar');
app.has('foo');
//=> true

.del

Delete key from the instance. Also emits del with the key of the deleted item.

Params

• key {String}
• returns {Object}: Returns the instance for chaining.

Events

• emits: del with the key as the only argument.

Example

app.del(); // delete all
// or
app.del('foo');
// or
app.del(['foo', 'bar']);

.define

Define a non-enumerable property on the instance. Dot-notation is not supported with define.

Params

• key {String}: The name of the property to define.
• value {any}
• returns {Object}: Returns the instance for chaining.

Events

• emits: define with key and value as arguments.

Example

// arbitrary `render` function using lodash `template`
define('render', function(str, locals) {
  return _.template(str)(locals);
});

.visit

Visit method over the items in the given object, or map visit over the objects in an array.

Params

• method {String}
• val {Object|Array}
• returns {Object}: Returns the instance for chaining.

.mixin

Mix property key onto the Base prototype. If base-methods is inherited using Base.extend this method will be overridden by a new mixin method that will only add properties to the prototype of the inheriting application.

Params

• key {String}
• val {Object|Array}
• returns {Object}: Returns the instance for chaining.

.use

Static method for adding global plugin functions that will be added to an instance when created.

Params

• fn {Function}: Plugin function to use on each instance.

Example

Base.use(function(app) {
  app.foo = 'bar';
});
var app = new Base();
console.log(app.foo);
//=> 'bar'

.extend

Static method for inheriting both the prototype and static methods of the Base class. See [class-utils][] for more details.

.Base.mixin

Static method for adding mixins to the prototype. When a function is returned from the mixin plugin, it will be added to an array so it can be used on inheriting classes via Base.mixins(Child).

Params

• fn {Function}: Function to call

Example

Base.mixin(function fn(proto) {
  proto.foo = function(msg) {
    return 'foo ' + msg;
  };
  return fn;
});

.Base.mixins

Static method for running currently saved global mixin functions against a child constructor.

Params

• Child {Function}: Constructor function of a child class

Example

Base.extend(Child);
Base.mixins(Child);

.inherit

Similar to util.inherit, but copies all static properties, prototype properties, and descriptors from Provider to Receiver. [class-utils][] for more details.

Test coverage

Statements   : 100% (88/88)
Branches     : 100% (32/32)
Functions    : 100% (19/19)
Lines        : 100% (87/87)

Related projects

There are a number of different plugins available for extending base. Let us know if you create your own!

• base-argv: Plugin for base-methods that simplifies mapping argv arguments to tasks, commands, and options | homepage
• base-cli: Plugin for base-methods that maps built-in methods to CLI args (also supports methods from a… more | homepage
• base-config: base-methods plugin that adds a config method for mapping declarative configuration values to other 'base'… more | homepage
• base-cwd: Base plugin that adds a getter/setter for the current working directory. | homepage
• base-data: adds a data method to base-methods. | homepage
• base-fs: base-methods plugin that adds vinyl-fs methods to your 'base' application for working with the file… more | homepage
• base-list: base-runner plugin that prompts the user to choose from a list of registered applications and… more | homepage
• base-options: Adds a few options methods to base-methods, like option, enable and disable. See the readme… more | homepage
• base-pipeline: base-methods plugin that adds pipeline and plugin methods for dynamically composing streaming plugin pipelines. | homepage
• base-plugins: Upgrade's plugin support in base-methods to allow plugins to be called any time after init. | homepage
• base-questions: Plugin for base-methods that adds methods for prompting the user and storing the answers on… more | homepage
• base-runner: Orchestrate multiple instances of base-methods at once. | homepage
• base-store: Plugin for getting and persisting config values with your base-methods application. Adds a 'store' object… more | homepage
• base-tasks: base-methods plugin that provides a very thin wrapper around https://github.com/jonschlinkert/composer for adding task methods to… more | homepage
• base-tree: Add a tree method to generate a hierarchical tree structure representing nested applications and child… more | homepage

Running tests

Install dev dependencies:

$ npm i -d && npm test

Contributing

Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.

Author

Jon Schlinkert

• github/jonschlinkert
• twitter/jonschlinkert

License

Copyright © 2016 Jon Schlinkert Released under the MIT license.

---

This file was generated by verb on January 25, 2016.